package com.yuefen.shenyumo;

import androidx.appcompat.app.AppCompatActivity;

import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Base64;
import android.util.Log;
import android.view.Window;
import android.view.WindowManager;
import android.webkit.WebResourceResponse;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

import java.nio.charset.StandardCharsets;
import java.util.HashSet;
import java.util.Set;

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;


public class MainActivity extends Activity {

    protected WebView mWebView;
    private long mStarTime;

//    public  static  String sURL="http://www.36ky.cn:88"; //正式服域名
//    public  static  String sURL="http://140.210.18.167:90/";//正式服ip
//    public  static  String sURL="http://101.33.245.40:90/";//测试服ip
//      public  static  String sURL="http://www.36ky.cn:88";//测试
//    public  static  String sURL="http://h5.cusf.cn";//奇迹风云
      public  static  String sURL="http://114.132.159.129:8008?signCode=baize";//九州谕

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 隐藏状态栏
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.activity_main);

        //初始化webView
        mWebView = (WebView) findViewById(R.id.web_view);

        initWebView();

        // 启动后台任务来执行网络请求 获取链接地址
//        new FetchDataFromGiteeTask().execute();

        // 加载 URL 到 WebView
        openUrl(sURL);
    }

    private class FetchDataFromGiteeTask extends AsyncTask<Void, Void, String> {
        @Override
        protected String doInBackground(Void... params) {
            // 在后台线程中执行网络请求
            // 这里执行获取文本内容的代码，包括使用你之前提到的 `getJSONFromGiteeRepo` 方法
            String textContent = getJSONFromGiteeRepo("freyStudio", "keytxt", "KEY.txt", "cddfe15e357bc80c0b30f2b1e6491715");

            try {
                // 尝试解析JSON以获取base64编码的内容
                JSONObject jsonObject = new JSONObject(textContent);
                String base64Content = jsonObject.getString("content");

                // 解码base64内容
                byte[] decodedBytes = Base64.decode(base64Content, Base64.DEFAULT);
                String decodedContent = new String(decodedBytes, StandardCharsets.UTF_8);

                return decodedContent;
            } catch (JSONException e) {
                // 如果解析JSON失败，那么假定它是纯文本
                return textContent;
            }
        }

        @Override
        protected void onPostExecute(String textContent) {
            // 在UI线程中处理获取到的文本内容
            Log.d("LJTAG", "Text Content: " + textContent);

            // 解析文本内容中的 URL
            String extractedUrl = parseUrlFromText(textContent);
            Log.d("LJTAG", "Extracted URL: " + extractedUrl);

            mStarTime = System.currentTimeMillis();
            // 加载 URL 到 WebView
            openUrl(extractedUrl);
        }
    }

    private String parseUrlFromText(String textContent) {
        return textContent;
    }


    public String getJSONFromGiteeRepo(String owner, String repo, String path, String token) {
        OkHttpClient client = new OkHttpClient();
        String url = "https://gitee.com/api/v5/repos/" + owner + "/" + repo + "/contents/" + path;

        Request request = new Request.Builder()
                .url(url)
                .addHeader("Authorization", "token " + token)
                .build();

        try {
            Response response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                String jsonContent = response.body().string();
                // 解析JSON内容或者返回它，根据你的需求
                return jsonContent;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

    private void initWebView() {
        WebSettings settings = mWebView.getSettings();
        // 启用 JavaScript
        settings.setJavaScriptEnabled(true);
        // 启用DOM存储
        settings.setDomStorageEnabled(true);
        // 启用缓存数据库
        settings.setDatabaseEnabled(true);
        //設置為pc瀏覽器
        settings.setUserAgentString("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36");

        mWebView.setWebViewClient(new WebViewClient() {
            @Override
            public WebResourceResponse shouldInterceptRequest(WebView view, String url) {
                // 在这里处理资源加载请求
                // 返回 WebResourceResponse 以提供资源的本地内容
                Log.d("LJTAG", "shouldInterceptRequest: " + url);
                return customResourceResponse(url);
            }

            @Override
            public boolean shouldOverrideUrlLoading(WebView wv, String url) {
                try {
                    // 拦截支付宝/微信支付
                    if (url.startsWith("alipays://platformapi/startApp?") ||
                            url.startsWith("alipays://platformapi/startapp?")) {
                        Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
                        startActivity(intent);
                        return true;
                    } else if (url.startsWith("weixin://")||url.startsWith("weixin://wap/pay?")) {
                        Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
                        startActivity(intent);
                        return true;
                    }

                    // 其他情况保持 WebView 默认的行为
                    return super.shouldOverrideUrlLoading(wv, url);
                } catch (Exception e) {
                    // 防止崩溃，如果手机上没有安装支付宝App或微信App
                    return true;
                }
            }

            @Override
            public void onPageFinished(WebView view, String url) {
                super.onPageFinished(view, url);
                Log.d("LJTAG", "useTime: " + (System.currentTimeMillis() - mStarTime));
            }
        });
    }


    // 判断是否需要缓存资源的方法
    private boolean shouldCacheResource(String url) {
        // 在这里添加条件判断，例如检查 URL 是否满足特定的 IP 地址或域名
        // 返回 true 表示需要缓存，false 表示不需要缓存
        return url.contains(sURL);
    }

    private WebResourceResponse customResourceResponse(String url) {
        if (!shouldCacheResource(url)) {
            return null; // 不需要缓存，直接返回 null
        }

        try {
            URL resourceUrl = new URL(url);
            Log.d("LJTAG", "开始处理Url: " + url);

            // 获取文件扩展名
            String fileExtension = getFileExtension(resourceUrl.getPath());

            Log.d("LJTAG", "文件扩展名: " + fileExtension);

            File cacheFile = null; // 初始化为null

            if (isResourceToBeHandled(url)) {
                Log.d("LJTAG", "文件夹名: " + resourceUrl.getPath());
                // 创建文件夹路径
                File folder = createFolderForResource(resourceUrl.getPath());
                Log.d("LJTAG", "文件夹名: " + folder.toString());

                // 获取资源的文件名
                String fileName = new File(resourceUrl.getPath()).getName();
                // 创建缓存文件
                cacheFile = new File(folder, fileName); // 分配一个值给cacheFile
                Log.d("LJTAG", cacheFile + " --缓存文件路径");

                if (cacheFile.exists()) {
                    // 检查缓存文件的修改时间
                    long cacheFileLastModified = cacheFile.lastModified();

                    // 获取服务器文件的最后修改时间
                    long serverLastModified = getLastModifiedTime(url);

                    if (serverLastModified > cacheFileLastModified) {
                        Log.d("LJTAG", "服务器文件已更新，重新下载并缓存");
                        // 重新下载资源并保存到本地
                        if (downloadAndSaveResource(resourceUrl, cacheFile)) {
                            Log.d("LJTAG", "资源下载并缓存成功");
                            // 更新缓存文件的修改时间
                            cacheFile.setLastModified(serverLastModified);
                        } else {
                            Log.d("LJTAG", "资源下载并缓存失败");
                        }
                    } else {
                        Log.d("LJTAG", "服务器文件未更改，直接使用缓存文件");
                    }
                } else {
                    Log.d("LJTAG", cacheFile.getAbsolutePath() + " 文件不存在，开始下载并缓存");

                    // 下载资源并保存到本地
                    if (downloadAndSaveResource(resourceUrl, cacheFile)) {
                        Log.d("LJTAG", "资源下载并缓存成功");

                        // 设置缓存文件的修改时间为服务器的修改时间
                        long serverLastModified = getLastModifiedTime(url);
                        cacheFile.setLastModified(serverLastModified);
                    } else {
                        Log.d("LJTAG", "资源下载并缓存失败");
                    }
                }
            }

            if (cacheFile != null) {
                FileInputStream fileInputStream = new FileInputStream(cacheFile);
                String contentType = getContentType(fileExtension);
                return new WebResourceResponse(contentType, "utf-8", fileInputStream);
            } else {
                // 如果没有缓存文件，可能需要直接从网络加载
                // 你可以在这里添加代码来处理从网络加载的情况
            }
        } catch (MalformedURLException e) {
            Log.d("LJTAG", "错误信息：" + e.getMessage());
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null; // 返回 null 以继续加载原始资源
    }



    private long getLastModifiedTime(String url) {
        try {
            URL resourceUrl = new URL(url);

            HttpURLConnection connection = (HttpURLConnection) resourceUrl.openConnection();
            connection.setRequestMethod("HEAD"); // 使用HEAD请求获取文件头信息，而不是实际文件内容
            connection.connect();

            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                long lastModified = connection.getLastModified();
                return lastModified;
            } else {
                Log.e("LJTAG", "HTTP request failed with response code: " + responseCode);
            }
        } catch (MalformedURLException e) {
            Log.e("LJTAG", "Malformed URL: " + e.getMessage());
        } catch (IOException e) {
            Log.e("LJTAG", "IO error: " + e.getMessage());
        }

        return -1; // 返回-1表示获取失败
    }

    private File createFolderForResource(String resourcePath) {
        String[] pathSegments = resourcePath.split("/");
        File folder = getExternalCacheDir();

        for (int i = 0; i < pathSegments.length - 1; i++) {
            folder = new File(folder, pathSegments[i]);
            if (!folder.exists()) {
                if (folder.mkdirs()) {
                    Log.d("LJTAG", "文件夹创建成功: " + folder.getAbsolutePath());
                } else {
                    Log.e("LJTAG", "文件夹创建失败: " + folder.getAbsolutePath());
                }
            } else {
                Log.d("LJTAG", "文件夹已存在: " + folder.getAbsolutePath());
            }
        }

        return folder;
    }
    //奇迹文件夹目录
//    private String getContentType(String fileExtension) {
//        switch (fileExtension.toLowerCase()) {
//            case "png":
//                return "image/png";
//            case "json":
//                return "application/json";
//            case "jpg":
//                return "image/jpeg";
//            case "js":
//                return "application/javascript";
//            case "zip":
//                return "application/zip";
//            default:
//                return "text/html"; // 默认返回 HTML 类型
//        }
//    }


    private String getContentType(String fileExtension) {
        switch (fileExtension.toLowerCase()) {
            case "cfg":
                return "application/cfg";
            case "atlas":
                return "application/atlas";
            case "map":
                return "application/map";
            case "lani":
                return "application/lani";
            case "scene":
                return "application/scene";
            case "lmat":
                return "application/lmat";
            case "lh":
                return "application/lh";
            case "lm":
                return "application/lm";
            case "ktx":
                return "application/ktx";
            case "png":
                return "image/png";
            case "json":
                return "application/json";
            case "jpg":
                return "image/jpeg";
            case "js":
                return "application/javascript";
            case "zip":
                return "application/zip";
            case "7z":
                return "application/7z";
            default:
                return ""; // 默认返回 HTML 类型
        }
    }

    private boolean isResourceToBeHandled(String url) {
        try {
            URL resourceUrl = new URL(url);

            // 检查资源的扩展名
            String fileExtension = getFileExtension(resourceUrl.getPath());

            // 定义要处理的扩展名集合
            Set<String> allowedExtensions = new HashSet<>();
            allowedExtensions.add("png");
            allowedExtensions.add("json");
            allowedExtensions.add("jpg");
            allowedExtensions.add("js");
            allowedExtensions.add("zip");

            // 检查扩展名是否在允许的扩展名集合中
            return allowedExtensions.contains(fileExtension);
        } catch (MalformedURLException e) {
            Log.d("LJTAG", "错误信息：" + e.getMessage());
        }
        return false; // 如果出现异常，默认返回 false
    }






    /**
     * shouldOverrideUrlLoading 是在页面内跳转的时候会被调用的方法
     * 第一次loadUrl的时候 是不会调用shouldOverrideUrlLoading方法的
     * 所以打开指定页面的时候要通过我们自己的方法去打开指定页面
     */
    private void openUrl(String url) {
        String cacheFileUrl = getCacheFileUrl(url);
        if (null != cacheFileUrl) {
            mWebView.loadUrl(cacheFileUrl);
        } else {
            mWebView.loadUrl(url);
        }
    }

    /**
     * 根据url判断本地缓存文件是否存在
     * 如果存在 则应用拦截本次url加载同时使用file协议访问该文件
     *
     * @param url
     * @return
     */
    private boolean shouldOverrideUrlLoading(String url) {
        String cacheFileUrl = getCacheFileUrl(url);
        if (cacheFileUrl == null) return false;

        mWebView.loadUrl(cacheFileUrl);
        return true;
    }

    /**
     * 如果Cache文件命中, 返回Cache文件的file协议地址,否则返回null
     *
     * @param aimUrl
     * @return
     */
    private String getCacheFileUrl(String aimUrl) {
        try {
            URL url = new URL(aimUrl);
            Log.d("LJTAG", "getCacheFileUrl: " + url);

            if (url.getProtocol().startsWith("http")) {
                String fileExtension = getFileExtension(url.getPath());

                if (fileExtension.equalsIgnoreCase("png")) {
                    // 如果文件扩展名为 PNG，执行下载和缓存
                    File cacheFile = new File(getExternalCacheDir(), url.getPath());

                    if (cacheFile.exists()) {
                        Log.d("LJTAG", cacheFile.getAbsolutePath() + " 文件存在, 直接使用file协议访问");
                        return "file://" + cacheFile.getAbsolutePath();
                    } else {
                        Log.d("LJTAG", cacheFile.getAbsolutePath() + " 文件不存在，开始下载并缓存");

                        // 下载资源并保存到本地
                        if (downloadAndSaveResource(url, cacheFile)) {
                            Log.d("LJTAG", "资源下载并缓存成功");
                            return "file://" + cacheFile.getAbsolutePath();
                        } else {
                            Log.d("LJTAG", "资源下载并缓存失败");
                        }
                    }
                } else {
                    // 如果文件不是 PNG，不下载，直接返回线上资源路径
                    Log.d("LJTAG", url.toString() + " 线上资源路径");
                    return url.toString();
                }
            }
        } catch (MalformedURLException e) {
            Log.d("LJTAG", "错误信息："+e.getMessage());
        }
        return null;
    }


    private String getFileExtension(String path) {
        int lastDotIndex = path.lastIndexOf(".");
        if (lastDotIndex > 0) {
            return path.substring(lastDotIndex + 1);
        }
        return "";
    }

    private boolean downloadAndSaveResource(URL url, File cacheFile) {
        // 在这里实现下载和保存资源的逻辑
        // 你可以使用 HttpURLConnection 或 OkHttp 等网络库来下载资源

        // 示例使用 HttpURLConnection 下载资源
        try {
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            InputStream inputStream = connection.getInputStream();
            FileOutputStream outputStream = new FileOutputStream(cacheFile);

            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }

            inputStream.close();
            outputStream.close();
            connection.disconnect();

            return true; // 下载并保存成功
        } catch (Exception e) {
            e.printStackTrace();
            return false; // 下载或保存失败
        }
    }






}